|
Compile-time function execution (or compile time function evaluation, or general constant expressions) is the ability of a compiler, that would normally compile a function to machine code and execute it at run time, to execute the function at compile time. This is possible if the arguments to the function are known at compile time, and the function does not make any reference to or attempt to modify any global state (is a pure function). If the value of only some of the arguments are known, the compiler may still be able to perform some level of compile-time function execution (partial evaluation), possibly producing more optimized code than if no arguments were known. ==Examples== The Lisp macro system is an early example of the use of compile-time evaluation of user-defined functions in the same language. The Metacode extension to C++ (Vandevoorde 2003)〔 〕 was an early experimental system to allow compile-time function evaluation (CTFE) and code injection as an improved syntax for C++ template metaprogramming. In earlier versions of C++, template metaprogramming is often used to compute values at compile time, such as: template template <> struct Factorial<0> ; // Factorial<4>::value == 24 // Factorial<0>::value == 1 void foo() Using compile-time function evaluation, code used to compute the factorial would be similar to what one would write for run-time evaluation e.g. using C++11 constexpr. #include constexpr int factorial(int n) constexpr int f10 = factorial(10); int main() In C++11, this technique is known as generalized constant expressions ( constexpr).〔(【引用サイトリンク】author=Gabriel Dos Reis and Bjarne Stroustrup )〕 C++14 relaxes the constraints on constexpr – allowing local declarations and use of conditionals and loops (the general restriction that all data required for the execution be available at compile-time remains).Here's an example of compile time function evaluation in the D programming language:〔(D 2.0 language specification: Functions )〕 int factorial(int n) // computed at compile time enum y = factorial(0); // == 1 enum x = factorial(4); // == 24 This example specifies a valid D function called "factorial" which would typically be evaluated at run time. The use of enum tells the compiler that the initializer for the variables must be computed at compile time. Note that the arguments to the function must be able to be resolved at compile time as well.〔(D 2.0 language specification: Attributes )〕CTFE can be used to populate data structures at compile-time in a simple way (D version 2): foreach (i; 1 .. n) result() = result(- 1 ) * i; return result; } enum factorials = genFactorials(13); void main() {} // 'factorials' contains at compile-time: // (1, 2, 6, 24, 120, 720, 5_040, 40_320, 362_880, 3_628_800, // 39_916_800, 479_001_600 ) 抄文引用元・出典: フリー百科事典『 ウィキペディア（Wikipedia）』 ■ウィキペディアで「compile time function execution」の詳細全文を読む スポンサード リンク
|